多线程十一 单例模式

发表于 | 分类于

本篇博文,将整理关于单例模式(就是让一个类从始至终,只能产生一个对象,而且spring管理的类也全部是单例模式的)与多线程摩擦出的火花

1 . 懒汉模式(存在线程安全性问题)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class demo01 {

//要实现单例,肯定不能new对象,因此我们私有化构造函数
private demo01(){}

//定义一个属于本类的单例对象,每次返回的都是这个对象
public static demo01  instance = null;

//因为我们没有自己创造出来的对象了,故提供一个静态工厂方法,返回对象的实例
public static demo01 getInstance(){
    if (instance==null){  //在多线程并发访问的情况下,是存在线程安全问题的
        instance = new demo01();
        return instance;
    }
    return instance;
}
}
  • 懒汉模式—在使用的时候初始化对象

2 . 饿汉模式(简单粗暴,实现线程安全)—-静态域

1
2
3
4
5
6
7
8
9
10
11
12
13
public class demo02 {

//要实现单例,肯定不能new对象,因此我们私有化构造函数
private demo02(){}

//定义一个属于本类的单例对象,每次返回的都是这个对象
private static demo02  instance = new  demo02();  // 静态域

//因为我们没有自己创造出来的对象了,故提供一个静态工厂方法,返回对象的实例
public static demo02 getInstance(){
    return instance;
}
}
  • 饿汉模式—在类加载的时候初始化对象,

缺点:

1 . 如果在构造函数中有过多的其他耗时操作的话,对象的创建会很慢
2 . 而且对象创建出来了还不一定会马上使用,造成资源的浪费

使用饿汉模式相应的注意点 :

  1. 对象创建出来以后肯定会被使用
  2. 构造函数没有太多其他处理

3 . 饿汉模式(简单粗暴,实现线程安全)—-静态块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class demo05 {
//要实现单例,肯定不能new对象,因此我们私有化构造函数
private demo05(){}

//注意点, 下面两段代码是有先后顺序的,假如说颠倒顺序,那么已经初始化的实例也会被重置为null
public static demo05  instance = null;

static {
    instance = new demo05();
}


//因为我们没有自己创造出来的对象了,故提供一个静态工厂方法,返回对象的实例
public static demo05 getInstance(){
    return instance;
}

}
  • 饿汉模式—在类加载的时候初始化对象,

缺点:

1 . 如果在构造函数中有过多的其他耗时操作的话,对象的创建会很慢
2 . 而且对象创建出来了还不一定会马上使用,造成资源的浪费

使用饿汉模式相应的注意点 :

  1. 对象创建出来以后肯定会被使用
  2. 构造函数没有太多其他处理

4. 懒汉模式—-使用synchronized实现线程安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class demo03 {
//要实现单例,肯定不能new对象,因此我们私有化构造函数
private demo03(){}

//定义一个属于本类的单例对象,每次返回的都是这个对象
public static demo03  instance = null;


public static synchronized demo03 getInstance(){
    if (instance==null){
        instance = new demo03();
        return instance;
    }
    return instance;
}

}
  • 加上synchronized 在多线程并发访问的情况下,不再有线程安全问题,但是并不推荐,因为同一时间只有有一个线程进入此静态方法,因此效率低

5. 懒汉模式—- 双重同步锁单例模式+volatile 实现线程安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class demo04 {

//要实现单例,肯定不能new对象,因此我们私有化构造函数
private demo04(){}

//定义一个属于本类的单例对象,每次返回的都是这个对象
public static volatile demo04 volatile instance = null;


// 双重同步锁单例模式
public static  demo04 getInstance(){
    if (instance==null){  // 检测 1
        synchronized (demo04.class){ //锁
            if (instance==null){  //检查 2
                instance = new demo04();
            }
        }
        return instance;
    }
    return instance;
}

}

为什么要加上volatile关键字?

这就要从ＣＰＵ的指令说起, 当我们执行　

1
new demo04();

分下面三步走

  1. memory = allocate(); //分配内存空间
  2. ctorInstance() //初始化对象
  3. instance = memory // 将对象的引用指向刚分配的内存空间

在单线程的情况下是不会发生任何线程安全问题的,但是! 多线程就会受到 指令重排序的影响, JVM和CPU优化–指令重排序可能出现下面的顺序

  1. memory = allocate(); //分配内存空间
  2. instance = memory // 将对象的引用指向刚分配的内存空间,
  3. ctorInstance() //初始化对象

这时候双重同步锁单例模式就会出现问题,比如AB两条线程 A运行到指令3却没有真正创建对象 , 然后B去判断instance此时不为空,拿到了instance,一旦调用就会出现问题

6. 使用枚举实现单例模式 –线程安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class demo06 {

private demo06(){}

public static demo06 getInstance(){
        return Singleton.INSTANCE.getDemo06Instance();
}

//私有的枚举类
private enum Singleton{
    INSTANCE;

    private demo06 demo06Instance;

    //JVM保证此构造方法绝对只会调用一次
    Singleton(){
        demo06Instance= new demo06();  //调用外部类私有的构造方法
    }

    public demo06 getDemo06Instance(){
        return demo06Instance;
    }
}
}

推荐使用这种方法

  • 相对懒汉模式,绝对性的保证的安全问题
  • 相对饿汉模式,当实例在使用的时候才开始初始化